// HTTP SSE 接口请求 - 适配AIAppHubUI项目
import Vue from 'vue'
import { v4 as uuidv4 } from 'uuid'
import { MESSAGE_TYPE, APP_KEY } from '@/utils/constants'
import { sendChatMessageStream } from '@/api/ai/chat'

// 创建事件总线（如果不存在）
if (!Vue.prototype.$eventHub) {
  Vue.prototype.$eventHub = new Vue()
}
const $e = Vue.prototype.$eventHub

let cache = null // 缓存
let timeoutTasks = {} // 超时任务管理
const msgSendTimeout = 2 * 60 * 1000 // 发送消息超时ms，此处超时默认为2min

let controller
class SseCls {
  constructor() {
    cache = {
      session_id: '', // 会话ID
      configInfo: null, // 配置信息
      chatsContent: [], // 会话聊天内容
      systemEvents: [], // 系统事件栈
      transferInfo: {
        transferStatus: false,
        transferAvatar: ''
      } // 当前转人工状态
    }
  }
  
  init() {
    // 获取基础配置
    this.sseQueryConfigInfo()
  }
  
  reset() {
    // 重置
    cache = {
      session_id: '', // 会话ID
      configInfo: null, // 配置信息
      chatsContent: [], // 会话聊天内容
      systemEvents: [], // 系统事件栈
      transferInfo: {
        transferStatus: false,
        transferAvatar: ''
      } // 当前转人工状态
    }
  }

  // 获取基础配置
  async sseQueryConfigInfo() {
    try {
      // 生成新的会话ID
      cache.session_id = uuidv4()
      console.log('SSE初始化完成，会话ID:', cache.session_id)
      
      // 触发配置信息更新事件
      if ($e && $e.$emit) {
        $e.$emit('client_configInfoChange', {
          configInfo: {
            session_id: cache.session_id,
            app_key: APP_KEY
          }
        })
      }
    } catch (error) {
      console.error('SSE配置获取失败:', error)
    }
  }
/*
  // 发送消息
  sseSendMsg(question, conversationId = '') {
    if (!question || !question.trim()) {
      console.warn('问题内容为空')
      return
    }

    const requestId = uuidv4()
    const timestamp = Date.now()

    // 添加用户消息到聊天记录
    const userMessage = {
      id: requestId,
      content: question,
      is_from_self: true,
      timestamp: timestamp,
      is_loading: false
    }

    cache.chatsContent.push(userMessage)

    // 注意：消息更新现在由ClientChat组件直接处理，不再通过全局事件

    // 准备请求数据
    const requestData = {
      message: question,
      conversationId: conversationId || cache.session_id,
      userId: 'user_' + Date.now() // 临时用户ID
    }

    // 使用AIAppHubUI项目的流式API
    const streamController = sendChatMessageStream(
      requestData,
      (content) => {
        // 处理流式响应内容
        this.handleStreamMessage(content, requestId)
      },
      (error) => {
        // 处理错误
        this.handleStreamError(error, requestId)
      },
      () => {
        // 处理完成
        this.handleStreamComplete(requestId)
      }
    )

    // 保存控制器用于中断
    timeoutTasks[requestId] = {
      controller: streamController,
      timeout: setTimeout(() => {
        this.handleTimeout(requestId)
      }, msgSendTimeout)
    }
  }

  // 处理流式消息
  handleStreamMessage(content, requestId) {
    if (typeof content === 'string') {
      // 文本内容
      this.updateOrCreateAIMessage(content, requestId, false)
    } else if (content.type === 'conversation') {
      // 会话ID更新
      cache.session_id = content.conversationId
    }
  }

  // 处理流式错误
  handleStreamError(error, requestId) {
    console.error('SSE流式响应错误:', error)
    
    // 添加错误消息
    const errorMessage = {
      id: requestId + '_error',
      content: '抱歉，服务暂时不可用，请稍后重试。',
      is_from_self: false,
      timestamp: Date.now(),
      is_final: true,
      showOption: true
    }

    cache.chatsContent.push(errorMessage)
    // 注意：错误消息现在由ClientChat组件直接处理，不再通过全局事件

    this.cleanupRequest(requestId)
  }

  // 处理流式完成
  handleStreamComplete(requestId) {
    console.log('SSE流式响应完成')
    this.cleanupRequest(requestId)
  }

  // 更新或创建AI消息
  updateOrCreateAIMessage(content, requestId, isFinal = false) {
    // 查找现有的AI消息
    let aiMessage = cache.chatsContent.find(msg => 
      !msg.is_from_self && msg.requestId === requestId
    )

    if (!aiMessage) {
      // 创建新的AI消息
      aiMessage = {
        id: requestId + '_ai',
        requestId: requestId,
        content: content,
        is_from_self: false,
        timestamp: Date.now(),
        is_final: isFinal,
        showOption: isFinal,
        loading_message: !isFinal
      }
      cache.chatsContent.push(aiMessage)
    } else {
      // 更新现有消息
      aiMessage.content += content
      aiMessage.is_final = isFinal
      aiMessage.showOption = isFinal
      aiMessage.loading_message = !isFinal
    }

    // 注意：消息更新现在由ClientChat组件直接处理，不再通过全局事件
  }
*/
  // 清理请求
  cleanupRequest(requestId) {
    if (timeoutTasks[requestId]) {
      clearTimeout(timeoutTasks[requestId].timeout)
      delete timeoutTasks[requestId]
    }
  }

  // 处理超时
  handleTimeout(requestId) {
    console.warn('SSE请求超时:', requestId)
    this.cleanupRequest(requestId)
  }

  // 停止生成
  stopGeneration() {
    // 中断所有进行中的请求
    Object.keys(timeoutTasks).forEach(requestId => {
      const task = timeoutTasks[requestId]
      if (task.controller && task.controller.abort) {
        task.controller.abort()
      }
      this.cleanupRequest(requestId)
    })
  }

  // 获取当前会话内容
  getChatsContent() {
    return cache.chatsContent
  }

  // 获取会话ID
  getSessionId() {
    return cache.session_id
  }
}

// 创建全局实例
const sseInstance = new SseCls()

// 挂载到Vue原型
Vue.prototype.$SseCls = sseInstance

export default sseInstance
